/*************************************************************************************
 * Nombre del archivo: GeneratedScanner.java
 * Universidad del Valle de Guatemala
 * Curso: Diseño de Lenguajes de Programación
 * @author martin
 *          Martín Guzmán 08041
 * Fecha: Abril de 2010
 * Descripción: Segundo proyecto. Clase que contiene el Scanner
 *          generado para el archivo de entrada
*************************************************************************************/

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.JFileChooser;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

public class GeneratedScanner {

	public LinkedList<String> tokens_posibles = new LinkedList<String>();
	public LinkedList<Token> tokens_encontrados = new LinkedList<Token>();


	/***********************************************
	* Método: GeneratedScanner
	* Uso: Constructor
	* @param cadena a evaluar
	***********************************************/
	public GeneratedScanner(String cadena) {
		//------------------------------------------
		tokens_posibles.add("while"); //"while"
		tokens_posibles.add("do"); //"do"
		tokens_posibles.add("number"); //digit{digit}
		tokens_posibles.add("decnumber"); //digit{digit}"."digit{digit}
		tokens_posibles.add("white"); //blanco{blanco}
		tokens_posibles.add("Token_Parser1"); //";"
		tokens_posibles.add("Token_Parser2"); //"."
		tokens_posibles.add("Token_Parser3"); //"+"
		tokens_posibles.add("Token_Parser4"); //"-"
		tokens_posibles.add("Token_Parser5"); //"*"
		tokens_posibles.add("Token_Parser6"); //"/"
		tokens_posibles.add("Token_Parser7"); //"("
		tokens_posibles.add("Token_Parser8"); //")"

		//------------------------------------------
		System.out.println("-----------------------------------\n");
		System.out.println("Cadena a revisar: \n"+cadena);
		System.out.println("-----------------------------------\n");
		//------------------------------------------
		String cadena1 = cadena;
		
		Retorno_Funcion ret = new Retorno_Funcion();
		do{
			ret = this.Opciones_Token(cadena1);
			cadena1 = this.Complementar_cadena(cadena1, ret.indice);
			Retorno_Funcion retA = this.Opciones_Token(cadena1);
			if(retA.aceptado==false){
				//System.out.println("si se metio 1");
				Pattern pattern = Pattern.compile("(\\s)+");
				Matcher matcher = pattern.matcher(cadena1);
				if (matcher.find()) {
				    if(matcher.start()==0){
					//System.out.println("si se metio 2");
					cadena1 = this.Complementar_cadena(cadena1, matcher.end());
			    	}
				}
			}
			if(ret.aceptado==true){
				System.out.println("Token encontrado: "+ret.token+" con la cadena: "+ret.cadena);
				int indice = this.tokens_posibles.indexOf(ret.token);
				tokens_encontrados.add(new Token(indice,this.tokens_posibles.get(indice),ret.cadena));
			}
			else{
				break;
			}
		}while(true);
		if(cadena1.isEmpty()==false){
			tokens_encontrados.add(new Token(-1,"EOF",cadena1));
			System.out.println("No se hizo match con ningún token en la siguiente cadena: "+cadena1);
		}
	}

	/***********************************************
	* Método: Opciones_KeyWords
	* Uso: Revisa si es algún keyword
	* @param cadena a evaluar
	***********************************************/
	public Retorno_Funcion Opciones_KeyWords(String cadena) {
		//------------------------------------------

		LinkedList<Retorno_Funcion> lista_ret = new LinkedList<Retorno_Funcion>();

		//------------------------------------------
		// Revisa: null
		Retorno_Funcion ret0 = this.while_0(cadena);
		if(ret0.aceptado==true){
			ret0.token = "while";
			lista_ret.add(ret0);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: null
		Retorno_Funcion ret1 = this.do_0(cadena);
		if(ret1.aceptado==true){
			ret1.token = "do";
			lista_ret.add(ret1);
		}
		//------------------------------------------

		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<Retorno_Funcion>() {
			public int compare(Retorno_Funcion o1, Retorno_Funcion o2) {
				Integer a1 = o1.cadena.length();
				Integer a2 = o2.cadena.length();
				return a2-a1;
			}
		});
		return lista_ret.getFirst();
	}

	/***********************************************
	* Método: Opciones_Token
	* Uso: Verifica si lo ingresado es alguna de las opciones de token
	* @param cadena a evaluar
	***********************************************/
	public Retorno_Funcion Opciones_Token(String cadena) {
		//------------------------------------------

		LinkedList<Retorno_Funcion> lista_ret = new LinkedList<Retorno_Funcion>();

		//------------------------------------------
		// Revisa: digit{digit}
		Retorno_Funcion ret0 = this.number(cadena);
		if(ret0.aceptado==true){
			ret0.token = "number";
			lista_ret.add(ret0);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: digit{digit}"."digit{digit}
		Retorno_Funcion ret1 = this.decnumber(cadena);
		if(ret1.aceptado==true){
			ret1.token = "decnumber";
			lista_ret.add(ret1);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: blanco{blanco}
		Retorno_Funcion ret2 = this.white(cadena);
		if(ret2.aceptado==true){
			ret2.token = "white";
			lista_ret.add(ret2);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: ";"
		Retorno_Funcion ret3 = this.Token_Parser1(cadena);
		if(ret3.aceptado==true){
			ret3.token = "Token_Parser1";
			lista_ret.add(ret3);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: "."
		Retorno_Funcion ret4 = this.Token_Parser2(cadena);
		if(ret4.aceptado==true){
			ret4.token = "Token_Parser2";
			lista_ret.add(ret4);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: "+"
		Retorno_Funcion ret5 = this.Token_Parser3(cadena);
		if(ret5.aceptado==true){
			ret5.token = "Token_Parser3";
			lista_ret.add(ret5);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: "-"
		Retorno_Funcion ret6 = this.Token_Parser4(cadena);
		if(ret6.aceptado==true){
			ret6.token = "Token_Parser4";
			lista_ret.add(ret6);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: "*"
		Retorno_Funcion ret7 = this.Token_Parser5(cadena);
		if(ret7.aceptado==true){
			ret7.token = "Token_Parser5";
			lista_ret.add(ret7);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: "/"
		Retorno_Funcion ret8 = this.Token_Parser6(cadena);
		if(ret8.aceptado==true){
			ret8.token = "Token_Parser6";
			lista_ret.add(ret8);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: "("
		Retorno_Funcion ret9 = this.Token_Parser7(cadena);
		if(ret9.aceptado==true){
			ret9.token = "Token_Parser7";
			lista_ret.add(ret9);
		}
		//------------------------------------------

		//------------------------------------------
		// Revisa: ")"
		Retorno_Funcion ret10 = this.Token_Parser8(cadena);
		if(ret10.aceptado==true){
			ret10.token = "Token_Parser8";
			lista_ret.add(ret10);
		}
		//------------------------------------------

		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<Retorno_Funcion>() {
			public int compare(Retorno_Funcion o1, Retorno_Funcion o2) {
				Integer a1 = o1.cadena.length();
				Integer a2 = o2.cadena.length();
				return a2-a1;
			}
		});
		return lista_ret.getFirst();
	}

	/***********************************************
	* Método: Scan
	* Uso: Retorna el primer token de la lista y lo saca
	* @return Token
	***********************************************/
	public Token Scan(){
		try{
			return this.tokens_encontrados.pop();
		}catch(Exception exp){
			return (new Token(-1,"ERROR",""));
		}
	}


	/***********************************************
	* Método: expect
	* Uso: Revisa si lo ingresado hace match con
	*      el patrón dado...
	* @param regex contiene la regex con la que hay que evaluar
	* @param cadena que hay que revisar que haga match
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion expect(int[] regex, String cadena) {
		for(int i=0;i<regex.length;i++){
			try{
				if(regex[i]!=(int)cadena.charAt(i)){
					return new Retorno_Funcion();
				}
			}catch(Exception exp){
				return new Retorno_Funcion();
			}
		}
		Retorno_Funcion ret = new Retorno_Funcion();
		ret.indice = regex.length;
		ret.cadena = cadena.substring(0,regex.length);
		ret.aceptado = true;
		return ret;
	}


	/***********************************************
	* Método: Complementar_cadena
	* Uso: Corta la cadena hasta el índice i
	* @param a contiene el índice hasta donde cortar
	* @param cadena contiene la cadena a cortar
	***********************************************/
	public String Complementar_cadena(String cadena, int a){
		try{
			String cadena2 = "";
			cadena2 = cadena.substring(a);
			//System.out.println("Cadena cortada: "+cadena2);
			return cadena2;
		}catch(Exception exp){
			System.out.println("Error al copiar cortar la cadena: "+cadena+" en el índice: "+a);
		}
		return "";
	}


	/***********************************************
	* Método: ANY
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de ANY
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion ANY(String cadena) {
		// ANY = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255}
		//------------------------------------------
		int[] regex = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
		LinkedList<Integer> lista = new LinkedList<Integer>();
		Retorno_Funcion ret = new Retorno_Funcion();
		for(int a : regex){
			lista.add(a);
		}
		if(cadena.isEmpty()==true){
			return new Retorno_Funcion();
		}
		if(lista.contains((int)cadena.charAt(0))==true){
			ret.aceptado=true;
			ret.indice=1;
			ret.cadena=""+cadena.charAt(0);
		}
		return ret;
	}


	/***********************************************
	* Método: digit
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de digit
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion digit(String cadena) {
		// digit = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57}
		//------------------------------------------
		int[] regex = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57};
		LinkedList<Integer> lista = new LinkedList<Integer>();
		Retorno_Funcion ret = new Retorno_Funcion();
		for(int a : regex){
			lista.add(a);
		}
		if(cadena.isEmpty()==true){
			return new Retorno_Funcion();
		}
		if(lista.contains((int)cadena.charAt(0))==true){
			ret.aceptado=true;
			ret.indice=1;
			ret.cadena=""+cadena.charAt(0);
		}
		return ret;
	}


	/***********************************************
	* Método: tab
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de tab
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion tab(String cadena) {
		// tab = {9}
		//------------------------------------------
		int[] regex = {9};
		LinkedList<Integer> lista = new LinkedList<Integer>();
		Retorno_Funcion ret = new Retorno_Funcion();
		for(int a : regex){
			lista.add(a);
		}
		if(cadena.isEmpty()==true){
			return new Retorno_Funcion();
		}
		if(lista.contains((int)cadena.charAt(0))==true){
			ret.aceptado=true;
			ret.indice=1;
			ret.cadena=""+cadena.charAt(0);
		}
		return ret;
	}


	/***********************************************
	* Método: eol
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de eol
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion eol(String cadena) {
		// eol = {10}
		//------------------------------------------
		int[] regex = {10};
		LinkedList<Integer> lista = new LinkedList<Integer>();
		Retorno_Funcion ret = new Retorno_Funcion();
		for(int a : regex){
			lista.add(a);
		}
		if(cadena.isEmpty()==true){
			return new Retorno_Funcion();
		}
		if(lista.contains((int)cadena.charAt(0))==true){
			ret.aceptado=true;
			ret.indice=1;
			ret.cadena=""+cadena.charAt(0);
		}
		return ret;
	}


	/***********************************************
	* Método: blanco
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de blanco
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion blanco(String cadena) {
		// blanco = {10, 13, 9, 32}
		//------------------------------------------
		int[] regex = {10, 13, 9, 32};
		LinkedList<Integer> lista = new LinkedList<Integer>();
		Retorno_Funcion ret = new Retorno_Funcion();
		for(int a : regex){
			lista.add(a);
		}
		if(cadena.isEmpty()==true){
			return new Retorno_Funcion();
		}
		if(lista.contains((int)cadena.charAt(0))==true){
			ret.aceptado=true;
			ret.indice=1;
			ret.cadena=""+cadena.charAt(0);
		}
		return ret;
	}


	/***********************************************
	* Método: otro
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de otro
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion otro(String cadena) {
		// otro = {97, 115}
		//------------------------------------------
		int[] regex = {97, 115};
		LinkedList<Integer> lista = new LinkedList<Integer>();
		Retorno_Funcion ret = new Retorno_Funcion();
		for(int a : regex){
			lista.add(a);
		}
		if(cadena.isEmpty()==true){
			return new Retorno_Funcion();
		}
		if(lista.contains((int)cadena.charAt(0))==true){
			ret.aceptado=true;
			ret.indice=1;
			ret.cadena=""+cadena.charAt(0);
		}
		return ret;
	}


	/***********************************************
	* Método: while_0
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de while_0
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion while_0(String cadena) {
		// while_0 = while
		//------------------------------------------
		int[] regex = {119, 104, 105, 108, 101};
		Retorno_Funcion ret = this.expect(regex,cadena);
		return ret;
	}


	/***********************************************
	* Método: do_0
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de do_0
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion do_0(String cadena) {
		// do_0 = do
		//------------------------------------------
		int[] regex = {100, 111};
		Retorno_Funcion ret = this.expect(regex,cadena);
		return ret;
	}


	/***********************************************
	* Método: FuncionTokenTerm1
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm1
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm1(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm1 = digit
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// digit es un ident
		Retorno_Funcion ret0 = this.digit(cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenExpr0
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenExpr0
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenExpr0(String cadena) {
		//------------------------------------------
		// TokenExpr:  FuncionTokenExpr0 = digit
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: digit en FuncionTokenTerm1
		Retorno_Funcion ret1 = this.FuncionTokenTerm1(cadena);
		if(ret1.aceptado==true){
			lista_ret.add(ret1.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm0
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm0
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm0(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm0 = digit{digit}
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// digit es un ident
		Retorno_Funcion ret0 = this.digit(cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------

		//------------------------------------------
		// {TokenExpr}
		// Revisa: digit en FuncionTokenExpr0
		Retorno_Funcion ret1 = new Retorno_Funcion();
		String cadena1 = cadenaA;
		while(true){
			Retorno_Funcion retB1 = this.FuncionTokenExpr0(cadena1);
			if(retB1.aceptado==false){
				break;
			}
			ret1.indice+= retB1.indice;
			ret1.cadena+= retB1.cadena;
			cadena1 = Complementar_cadena(cadena1, retB1.indice);
		}
		cadenaA = cadena1;
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.indice+=ret1.indice;
		ret.cadena+=ret1.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: number
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de number
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion number(String cadena) {
		//------------------------------------------
		// TokenExpr:  number = digit{digit}
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: digit{digit} en FuncionTokenTerm0
		Retorno_Funcion ret0 = this.FuncionTokenTerm0(cadena);
		if(ret0.aceptado==true){
			lista_ret.add(ret0.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm3
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm3
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm3(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm3 = digit
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// digit es un ident
		Retorno_Funcion ret0 = this.digit(cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenExpr1
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenExpr1
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenExpr1(String cadena) {
		//------------------------------------------
		// TokenExpr:  FuncionTokenExpr1 = digit
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: digit en FuncionTokenTerm3
		Retorno_Funcion ret3 = this.FuncionTokenTerm3(cadena);
		if(ret3.aceptado==true){
			lista_ret.add(ret3.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm4
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm4
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm4(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm4 = digit
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// digit es un ident
		Retorno_Funcion ret0 = this.digit(cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenExpr2
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenExpr2
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenExpr2(String cadena) {
		//------------------------------------------
		// TokenExpr:  FuncionTokenExpr2 = digit
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: digit en FuncionTokenTerm4
		Retorno_Funcion ret4 = this.FuncionTokenTerm4(cadena);
		if(ret4.aceptado==true){
			lista_ret.add(ret4.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm2
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm2
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm2(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm2 = digit{digit}"."digit{digit}
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// digit es un ident
		Retorno_Funcion ret0 = this.digit(cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------

		//------------------------------------------
		// {TokenExpr}
		// Revisa: digit en FuncionTokenExpr1
		Retorno_Funcion ret1 = new Retorno_Funcion();
		String cadena1 = cadenaA;
		while(true){
			Retorno_Funcion retB1 = this.FuncionTokenExpr1(cadena1);
			if(retB1.aceptado==false){
				break;
			}
			ret1.indice+= retB1.indice;
			ret1.cadena+= retB1.cadena;
			cadena1 = Complementar_cadena(cadena1, retB1.indice);
		}
		cadenaA = cadena1;
		//------------------------------------------

		//------------------------------------------
		// "." es un string
		int[] regex2 = {46};
		Retorno_Funcion ret2 = this.expect(regex2,cadenaA);
		if(ret2.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret2.indice);
		//------------------------------------------

		//------------------------------------------
		// digit es un ident
		Retorno_Funcion ret3 = this.digit(cadenaA);
		if(ret3.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret3.indice);
		//------------------------------------------

		//------------------------------------------
		// {TokenExpr}
		// Revisa: digit en FuncionTokenExpr2
		Retorno_Funcion ret4 = new Retorno_Funcion();
		String cadena4 = cadenaA;
		while(true){
			Retorno_Funcion retB4 = this.FuncionTokenExpr2(cadena4);
			if(retB4.aceptado==false){
				break;
			}
			ret4.indice+= retB4.indice;
			ret4.cadena+= retB4.cadena;
			cadena4 = Complementar_cadena(cadena4, retB4.indice);
		}
		cadenaA = cadena4;
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.indice+=ret1.indice;
		ret.cadena+=ret1.cadena;
		ret.indice+=ret2.indice;
		ret.cadena+=ret2.cadena;
		ret.indice+=ret3.indice;
		ret.cadena+=ret3.cadena;
		ret.indice+=ret4.indice;
		ret.cadena+=ret4.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: decnumber
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de decnumber
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion decnumber(String cadena) {
		//------------------------------------------
		// TokenExpr:  decnumber = digit{digit}"."digit{digit}
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: digit{digit}"."digit{digit} en FuncionTokenTerm2
		Retorno_Funcion ret2 = this.FuncionTokenTerm2(cadena);
		if(ret2.aceptado==true){
			lista_ret.add(ret2.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm6
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm6
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm6(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm6 = blanco
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// blanco es un ident
		Retorno_Funcion ret0 = this.blanco(cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenExpr3
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenExpr3
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenExpr3(String cadena) {
		//------------------------------------------
		// TokenExpr:  FuncionTokenExpr3 = blanco
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: blanco en FuncionTokenTerm6
		Retorno_Funcion ret6 = this.FuncionTokenTerm6(cadena);
		if(ret6.aceptado==true){
			lista_ret.add(ret6.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm5
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm5
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm5(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm5 = blanco{blanco}
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// blanco es un ident
		Retorno_Funcion ret0 = this.blanco(cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------

		//------------------------------------------
		// {TokenExpr}
		// Revisa: blanco en FuncionTokenExpr3
		Retorno_Funcion ret1 = new Retorno_Funcion();
		String cadena1 = cadenaA;
		while(true){
			Retorno_Funcion retB1 = this.FuncionTokenExpr3(cadena1);
			if(retB1.aceptado==false){
				break;
			}
			ret1.indice+= retB1.indice;
			ret1.cadena+= retB1.cadena;
			cadena1 = Complementar_cadena(cadena1, retB1.indice);
		}
		cadenaA = cadena1;
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.indice+=ret1.indice;
		ret.cadena+=ret1.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: white
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de white
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion white(String cadena) {
		//------------------------------------------
		// TokenExpr:  white = blanco{blanco}
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: blanco{blanco} en FuncionTokenTerm5
		Retorno_Funcion ret5 = this.FuncionTokenTerm5(cadena);
		if(ret5.aceptado==true){
			lista_ret.add(ret5.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm7
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm7
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm7(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm7 = ";"
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// ";" es un string
		int[] regex0 = {59};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser1
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser1
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser1(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser1 = ";"
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: ";" en FuncionTokenTerm7
		Retorno_Funcion ret7 = this.FuncionTokenTerm7(cadena);
		if(ret7.aceptado==true){
			lista_ret.add(ret7.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm8
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm8
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm8(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm8 = "."
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// "." es un string
		int[] regex0 = {46};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser2
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser2
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser2(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser2 = "."
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: "." en FuncionTokenTerm8
		Retorno_Funcion ret8 = this.FuncionTokenTerm8(cadena);
		if(ret8.aceptado==true){
			lista_ret.add(ret8.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm9
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm9
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm9(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm9 = "+"
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// "+" es un string
		int[] regex0 = {43};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser3
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser3
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser3(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser3 = "+"
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: "+" en FuncionTokenTerm9
		Retorno_Funcion ret9 = this.FuncionTokenTerm9(cadena);
		if(ret9.aceptado==true){
			lista_ret.add(ret9.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm10
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm10
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm10(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm10 = "-"
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// "-" es un string
		int[] regex0 = {45};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser4
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser4
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser4(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser4 = "-"
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: "-" en FuncionTokenTerm10
		Retorno_Funcion ret10 = this.FuncionTokenTerm10(cadena);
		if(ret10.aceptado==true){
			lista_ret.add(ret10.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm11
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm11
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm11(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm11 = "*"
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// "*" es un string
		int[] regex0 = {42};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser5
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser5
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser5(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser5 = "*"
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: "*" en FuncionTokenTerm11
		Retorno_Funcion ret11 = this.FuncionTokenTerm11(cadena);
		if(ret11.aceptado==true){
			lista_ret.add(ret11.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm12
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm12
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm12(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm12 = "/"
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// "/" es un string
		int[] regex0 = {47};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser6
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser6
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser6(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser6 = "/"
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: "/" en FuncionTokenTerm12
		Retorno_Funcion ret12 = this.FuncionTokenTerm12(cadena);
		if(ret12.aceptado==true){
			lista_ret.add(ret12.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm13
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm13
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm13(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm13 = "("
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// "(" es un string
		int[] regex0 = {40};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser7
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser7
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser7(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser7 = "("
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: "(" en FuncionTokenTerm13
		Retorno_Funcion ret13 = this.FuncionTokenTerm13(cadena);
		if(ret13.aceptado==true){
			lista_ret.add(ret13.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

	/***********************************************
	* Método: FuncionTokenTerm14
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de FuncionTokenTerm14
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion FuncionTokenTerm14(String entrada) {
		//------------------------------------------
		// TokenTerm: FuncionTokenTerm14 = ")"
		//------------------------------------------
		String cadenaA = entrada;
		Retorno_Funcion ret = new Retorno_Funcion();

		//------------------------------------------
		// ")" es un string
		int[] regex0 = {41};
		Retorno_Funcion ret0 = this.expect(regex0,cadenaA);
		if(ret0.aceptado==false){
			return new Retorno_Funcion();
		}
		cadenaA = Complementar_cadena(cadenaA, ret0.indice);
		//------------------------------------------
		ret.indice+=ret0.indice;
		ret.cadena+=ret0.cadena;
		ret.aceptado=true;
		return ret;

	}

	/***********************************************
	* Método: Token_Parser8
	* Uso: Revisa si lo ingresado hace match con
	*      toda la sintaxis de Token_Parser8
	* @param cadena
	* @return Retorno_Funcion
	***********************************************/
	public Retorno_Funcion Token_Parser8(String cadena) {
		//------------------------------------------
		// TokenExpr:  Token_Parser8 = ")"
		//------------------------------------------

		Retorno_Funcion ret = new Retorno_Funcion();

		LinkedList<String> lista_ret = new LinkedList<String>();

		//------------------------------------------
		// Revisa: ")" en FuncionTokenTerm14
		Retorno_Funcion ret14 = this.FuncionTokenTerm14(cadena);
		if(ret14.aceptado==true){
			lista_ret.add(ret14.cadena);
		}
		//------------------------------------------
		if(lista_ret.size()==0){
			return (new Retorno_Funcion());
		}
		Collections.sort(lista_ret, new Comparator<String>() {
			public int compare(String o1, String o2) {
				Integer a1 = o1.length();
				Integer a2 = o2.length();
				return a2-a1;
			}
		});
		//System.out.println(lista_ret.toString());
		ret.aceptado=true;
		ret.indice=lista_ret.getFirst().length();
		ret.cadena=lista_ret.getFirst();
		return ret;

	}

}